go学习笔记-1

1. 变量的定义

   • 只定义，不赋值

   //会有初值
   var a int
   var s string

   • 定义和赋值

   var a int = 3
   var s string = "abs"
   #一次定义多个同类型的变量
   var a, b int = 3, 4

   • 系统判别类型

   var a, b, c, s = 2, 3, 4, "def"

   • 短格式

   c := 5
   a, b, s, d := 2, 3, "def", 5
   d = 6 

   • 在函数外部集中定义

   //在函数外部不能使用短格式定义
   var (
       a = 3
       b = 4
       s = "hell"
   )

2. 内建变量的类型

   • 分类

   bool,string
   (u)int,(u)int8|16|32|64,uintptr(指针)
   byte,rune(字符)
   float32|64,complex64|128（复数）

   • 强类型

   //打印变量的类型
   func main() {
       var a int = 89
       b := 95
       fmt.Println("value of a is", a, "and b is", b)
       fmt.Printf("type of a is %T, size of a is %d", a, unsafe.Sizeof(a)) // a 的类型和大小
       fmt.Printf("\ntype of b is %T, size of b is %d", b, unsafe.Sizeof(b)) // b 的类型和大小
   }

   • 数据类型的转换

   func main() {
       i := 55      //int
       j := 67.8    //float64
       sum := i + int(j) //不同类型的数据不允许进行运算 这里需要强制转换
       var c int
       c = int(j) //赋值也是一样
       fmt.Println(sum, c)
   }

3. 常量

   • 定义

   func main() {
       const name = "mengyuan" //不指定类型
       #const name string = "mengyuan" //指定类型
       fmt.Printf("type %T value %v\n", name, name)
       const(
           a = 1
           s = "mengyuan"
       ) //一次定义多个类型
   }

   • 注意

   //因为是强类型语言
   //赋值操作需要两边的类型一致 常量如果不指定类型的话就不需要注意
   func main() {
       const trueConst = true //类型不确定
       type myBool bool
       var defaultBool bool = trueConst // 允许 在赋值时确定类型
       var customBool myBool = trueConst // 允许
       //defaultBool = customBool // 不允许
   
       fmt.Println(defaultBool, customBool)
   }

   • 枚举

   func main() {
       const(
           cpp = 0
           java = 1
           python = 2
           golang = 3
           js = 4
       )
       //自增值枚举类型
       const(
           cpp = iota
           java
           python
           golang
           js
       )
   }

4. if-else

   • 格式

   if condition {
       doing
   } else if condition {
       doing
   } else {
       doing
   }

   • 注意点

   //判断奇偶
   func main() {
       if num := 10; num % 2 == 0 { //可以连写 但是变量num的作用范围仅仅在if语句中
           fmt.Println("the number is even") 
       } else { // }和else必须是在一行 不能换行
           fmt.Println("the number is odd")
       }
   }

5. switch

   • 连写模式

   //num := 5
   switch num := 2; num { // num 的作用域在switch
   case 1:
       fmt.Println("php")
   case 2:
       fmt.Println("python")
   case 3:
       fmt.Println("java")
   // case 3: case不允许出现重复项
   //    fmt.Println("js")
   case 4:
       fmt.Println("cpp")
   case 5:
       fmt.Println("golang")
   default: // default可以写在任何位置
       fmt.Println("default")
   }

   • 无表达式

   nums := 2
   switch {  //相当于switch true
   case nums <= 2: 
       fmt.Println("E")
   case nums <= 5:
       fmt.Println("D")
   case nums <= 6:
       fmt.Println("C")
   //case 3: case不允许出现重复项
   //    fmt.Println("js")
   case nums <= 8:
       fmt.Println("B")
   case nums <= 10:
       fmt.Println("A")
   default:
       fmt.Println("default")
   }

   • 多表达式(多种情况 一种处理方式)

   // 包含多个表达式
   numbers := 5
   switch numbers {
   case 2, 3, 4, 5:
       fmt.Println("the number <= 5")
   case 6, 7, 8, 9, 10:
       fmt.Println("the number <= 5")
   }

   • fallthrough 语句

   // 使用 fallthrough 语句可以在已经执行完成的 case 之后，把控制权转移到下一个 case 的执行代码中
   number := 5
   switch number {
   case 2:
       fmt.Println("E")
       fallthrough
   case 5:
       fmt.Println("D")
       fallthrough
   case 6:
       fmt.Println("C")
       fallthrough
   //case 3: case不允许出现重复项
   //    fmt.Println("js")
   case 8:
       fmt.Println("B")
       fallthrough
   case 10:
       fmt.Println("A")
   }

6. 循环

   • 标准示例

   // for循环语句包括 初始条件 终止条件 post语句 三部分
   //num := 10
   for i := 1; i <= 10; i++ {
       fmt.Println(i)
   }

   • continue 终止本次循环

   //num := 10
   for i := 1; i <= 10; i++ {
       if i%2 == 0 {
           continue
       }
       fmt.Println(i)
   }

   • break 跳出整个循环

   //num := 10
   for i := 1; i <= 10; i++ {
       if i > 7 {
           break
       }
       fmt.Println(i)
   }

   • 模仿while

   i := 1
   for i <= 10 {
       fmt.Println(i)
       i++
   }

   • 死循环

   for {
       fmt.Println("hello")
   }

7. 函数

   • 定义

   func calculateBill(num int, price int) int {
       ret := num * price
       return ret
   }
   //同类型的参数可以简写 返回值类型可以不写
   func calculateBill(num,price int) int {
       ret := num * price
       return ret
   }

   • 调用

   func main() {
       price, num := 4, 5//定义变量
       ret := calculateBillSimple(num, price)//调用
       fmt.Println(ret)
       //空白符
       var a, _ = rectPropsName(2, 4)
       fmt.Printf("the area is %.2f \n", a)
   }

   • 多返回值

   //多返回值
   func rectProps(length, width float64) (float64, float64) {
       var area = length * width
       var perimeter = (length + width) * 2
       return area, perimeter
   }

   • 命名返回值

   func rectPropsName(length, width float64) (area float64, perimeter float64) {
       area = length * width
       perimeter = (length + width) * 2
       return
   }

8. 指针

   • 定义

   // 指针的典型例子
   var a int = 2
   var pa *int = &a
   *pa = 3
   fmt.Println(a)

   • 动态改变变量的值

   func swap(a, b *int) {
       *a, *b = *b, *a
   }
   func swapNew(a, b int) (int, int) {
       a, b = b, a
       return a, b
   }
   
   func main() {
       // 交换变量的值
       a, b := 3, 4
       //swap(&a, &b)
       a, b = swapNew(a, b)
       fmt.Println(a, b)
   }

9. 搭建一个web服务

   • net/http模块

   // 当然不支持高并发
   package main
   import (
       "net/http"
   )
   func main() {
       http.Handle("/", http.FileServer(http.Dir(".")))
       http.ListenAndServe(":8080", nil)
   }